import { timeoutTask, showWxToast, timeIncrement, timeIncrementWithHours } from "../../utils/index";
import { setLastId, getLastId } from "../../utils/storage";
import {
  diceRecharge,
  getDiceInfo,
  startDiceGame,
  getDiceRankList,
} from "../../api/diceGame/diceGame";
import { wxPay } from "../../api/pay";
import { getPointInfo, robPoint, playPoint } from "../../api/pointStorm/pointStorm";

// 默认头像
const HEADIMG =
  "https://ustatic.009bar.com/hmbarscreen-qn/static/img/defaultHeadImg.a474c324.png";
let btnLock = false;
let timerInterval = null; // 倒计时计时器
// 定义用于轮询游戏是否开始的计时器
let loopGameStartTimer = null;
// 定义用于定期调用judgeGameEnd的计时器
let judgeGameEndTimer = null;
const isExpired = (timestamp) => {
  // 如果时间戳为0，表示游戏未开始，返回false
  if (timestamp === 0) {
    return false;
  }
  const date = new Date();
  var currentTimestamp = date.getTime();
  if (timestamp <= currentTimestamp) {
    return true;
  } else {
    return false;
  }
};

// 提取 data1 中的骰子结果为字符串数组（去掉下划线后的总和）
function extractDiceStrArray(d1) {
  let diceStrArr = [];
  if (d1 && typeof d1 === "object") {
    const size = parseInt(d1.size, 10) || 0;
    if (size > 0) {
      for (let i = 1; i <= size; i++) {
        const key = String(i);
        const val = d1[key];
        if (val) {
          diceStrArr.push(String(val).split("_")[0]);
        }
      }
    } else {
      const numericKeys = Object.keys(d1)
        .filter((k) => /^\d+$/.test(k))
        .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
      numericKeys.forEach((k) => {
        diceStrArr.push(String(d1[k]).split("_")[0]);
      });
    }
  } else if (typeof d1 === "string") {
    diceStrArr = [String(d1).split("_")[0]];
  }
  return diceStrArr;
}


Page({
  data: {
    dialogVisible: false,
    // 定义属性：dialogType 弹框类型
    // 类型：字符串
    // 取值：rule、record、challengeSuccess、challengeFail、gameSuccess、gameFail
    dialogType: "",
    gameStatus: 1, // 游戏状态(控制页面显示)
    userId: "",
    openId: "",
    pointChanceId: "", //一场游戏的id 0表示要先充值 1表示可以直接摇色子
    endTime: "", // 游戏结束时的时间戳
    remainTimeFormat: "00:00:00:00",
    ruleVisible: false,
    playRecords: [
    ], // 摇骰子的记录 数据项举例:{diceVal,diceStr,isChallengeSuccess, dateTime}
    isFirstInitPlayRecord: true, // 标识是否首次更新playRecords
    diceStr: [],
    diceVal: "",
    currenttimes: 1,
    currentRank: 0,
    rankList: [
    ],
    hasCustomConfig: false, // 是否有自定义配置
    // 积分风暴游戏配置
    pointConfig: {
      gameTime: 0, // 游戏时长（分钟）
      perPrice: 0, // 每次参与价格
      prizeNum: 0, // 奖品数量
      awardData: [], // 奖品数据数组
    },
    myAwardData: {}, // 我的奖品数据
    myInfo: {}, // 我的信息
    gameEnded: false, // 游戏是否已结束
    currentUserInfo: {}, // 当前用户信息（用于gamePlay弹窗）

  },
  onLoad: async function (options) {
    console.log(options);
    this.clearCdTimer();
    // 清空"用于轮询游戏是否开始的"计时器
    this.clearLoopGameStartTimer();
    // 启动judgeGameEnd定时器
    this.startJudgeGameEndTimer();
    this.setData({
      userId: options.userId,
      openId: options.openId,
    });
    // 调用积分风暴接口
    try {
      const pointInfoRes = await getPointInfo({ cancelLoading: true });
      console.log('积分风暴接口响应:', pointInfoRes);
      this.handlePointJsonData(pointInfoRes.data);
    } catch (error) {
      console.error('积分风暴接口调用失败:', error);
    }
  },
  onShow: function () {
    this.loopAskGameIsStart();
    // 启动judgeGameEnd定时器
    if(this.data.gameStatus === 2 && !judgeGameEndTimer) {
      this.startJudgeGameEndTimer();
    }
  },
  onHide: function () {
    this.clearCdTimer();
    // 清空"用于轮询游戏是否开始的"计时器
    this.clearLoopGameStartTimer();
    // 清空judgeGameEnd定时器
    this.clearJudgeGameEndTimer();
  },
  onUnload: function () {
    this.clearCdTimer();
    // 清空"用于轮询游戏是否开始的"计时器
    this.clearLoopGameStartTimer();
    // 清空judgeGameEnd定时器
    this.clearJudgeGameEndTimer();
  },
  /**
   * 打开弹窗
   * @param {object} e 参数
   * @example
   * 参数：{dialogType:'challengeSuccess'}
   * // 打开挑战成功弹窗(非点击触发)
   * 参数：{currentTarget：{dataset: {type:'rule'}}}
   * // 打开规则弹窗(点击触发)
   */
  openDialog(e) {
    console.log(e);
    if (e.dialogType==='challengeSuccess' || e.dialogType==='challengeFail') {
      this.setData({
        diceStr: e.diceStr || [],
        diceVal: e.diceVal || "",
        dialogType: e.dialogType,
        dialogVisible: true,
        currenttimes: e.diceStr.length,
      });
    } else if (e.dialogType === 'gamePlay') {
      // 处理gamePlay弹窗
      this.setData({
        dialogType: e.dialogType,
        dialogVisible: true,
        currentUserInfo: e.currentUserInfo || {
          headImg: HEADIMG,
          nickname: '用户'
        },
        currenttimes: e.currenttimes || 1,
      });
    } else {
      // 检查是否有 currentTarget，如果没有则使用 dialogType
      const dialogType = e.currentTarget ? e.currentTarget.dataset.type : e.dialogType;
      this.setData({
        dialogType: dialogType,
        dialogVisible: true,
      });
    }
  },
  endGame() {
    console.log('endGame');
    this.setData({
      gameStatus: 3,
      gameEnded: true,
    });
    this.clearCdTimer();
    // 根据服务端返回的结果 判断当前用户最终是否挑战成功
    getPointInfo({ cancelLoading: true })
      .then((res) => {
        // 获取 lotteryInfo
        const lotteryInfo = res.data.diceRank && res.data.diceRank.lotteryInfo;
        console.log('lotteryInfo:', lotteryInfo);
        
        // 更新排行榜数据（仅取前 prizeNum 个）
        if (res.data.diceRank && res.data.diceRank.list) {
          const prizeNum = this.data.pointConfig && this.data.pointConfig.prizeNum ? this.data.pointConfig.prizeNum : 1;
          const rankSrcList = Array.isArray(res.data.diceRank.list) ? res.data.diceRank.list : [];
          const limitedRankList = prizeNum > 0 ? rankSrcList.slice(0, prizeNum) : rankSrcList;
          this.setData({
            rankList: limitedRankList
          });
        }
        
        if (lotteryInfo) {
          // 根据 rank 判断游戏结果：rank 为 0 则失败，否则成功
          let gameResult = lotteryInfo.rank === 0 ? "gameFail" : "gameSuccess";
          
          // 如果游戏成功，根据 rank 值设置对应的奖品数据
          if (gameResult === "gameSuccess" && lotteryInfo.rank > 0) {
            const awardIndex = lotteryInfo.rank - 1; // rank 从 1 开始，数组从 0 开始
            if (this.data.pointConfig.awardData && this.data.pointConfig.awardData[awardIndex]) {
              this.setData({
                myAwardData: this.data.pointConfig.awardData[awardIndex]
              });
            }
          }
          
          // 设置我的信息，将 score 从浮点数转换为整数
          if (lotteryInfo.info) {
            const myInfo = {
              ...lotteryInfo.info,
              score: Math.floor(lotteryInfo.info.score) // 将浮点数转换为整数
            };
            this.setData({
              myInfo: myInfo
            });
          }
          
          this.openDialog({
            dialogType: gameResult,
          });
        } else {
          this.openDialog({
            dialogType: "gameFail",
          });
        }
      })
      .catch((err) => {
        console.log(err);
      });
  },
  initPointInfo() {
    getPointInfo({ cancelLoading: true })
      .then((res) => {
        // console.log(res);
        this.setData({
          endTime: res.data.endTime,
        });
        // 根据endTime来判断
        if (
          this.data.endTime === "0" ||
          isExpired(parseInt(res.data.endTime, 10))
        ) {
          // 游戏未开始
          this.setData({
            gameStatus: 1,
          });
          // showWxToast("游戏尚未开始!");
        } else {
          // 游戏开始
          this.setData({
            gameStatus: 2,
            pointChanceId: res.data.id,
          });
          // 清空"用于轮询游戏是否开始的"计时器
          this.clearLoopGameStartTimer();
          // 执行倒计时逻辑
          timerInterval = setInterval(() => {
            const time = timeIncrementWithHours(this.data.endTime);
            if (time.total <= 0) {
              this.clearCdTimer();
            } else {
              this.setData({
                remainTimeFormat: `${time.h}:${time.m}:${time.s}:${time.ms}`,
              });
              const tmpSecond = parseInt(time.total / 1000, 10);
              if (tmpSecond % 3 === 0 && this.data.tmpSecond !== tmpSecond) {
                this.setData({
                  tmpSecond, // 记住上一次不重复的秒数
                });
              }
            }
          }, 10);
        }
      })
      .catch((err) => {
        console.log(err);
      });
  },
  judgeGameEnd() {
    getPointInfo({ cancelLoading: true })
      .then((res) => {
        console.log(res);
        
        // 更新当前用户排名
        let currentRank = 0;
        if (res.data.diceRank && res.data.diceRank.lotteryInfo && res.data.diceRank.lotteryInfo.rank) {
          currentRank = res.data.diceRank.lotteryInfo.rank;
        }
        
        // 与 endGame 保持一致：排行榜仅取前 prizeNum 个
        let limitedRankList = [];
        if (res.data && res.data.diceRank && Array.isArray(res.data.diceRank.list)) {
          const prizeNum = this.data.pointConfig && this.data.pointConfig.prizeNum ? this.data.pointConfig.prizeNum : 1;
          const rankSrcList = res.data.diceRank.list;
          limitedRankList = prizeNum > 0 ? rankSrcList.slice(0, prizeNum) : rankSrcList;
        }

        this.setData({
          pointChanceId: res.data.id,
          currentRank: currentRank,
          rankList: limitedRankList,
          endTime: res.data.endTime,
        });
        if(this.data.endTime === "0") {
            this.setData({
                gameStatus: 1,
                gameEnded: false,
            });
            // 游戏重置了，如果倒计时定时器未启动，则重新启动
            if (!timerInterval) {
              this.initPointInfo();
            }
        }else if(!isExpired(parseInt(res.data.endTime, 10))){
            this.setData({
                gameStatus: 2,
            });
        }
        const tmpRecords = res.data.array.map((item) => {
          const d1 = item && item.data1;
          const diceValNum = Number(item && item.data2);
          // 判断item.data3是否为0，如果为0则没有成功，不为0则为成功
          const rankNum = Number(item.data3); // 将字符串转换为数字
          const success = rankNum !== 0; // 不为0则为成功
          
          return {
            diceStr: extractDiceStrArray(d1),
            diceVal: item.data2,
            rank: rankNum, 
            isChallengeSuccess: success,
            dateTime: item.time,
            id:item.id,
          };
        });
        this.updatePlayRecords(tmpRecords);
        // console.log('judgeGameEnd',res.data.endTime,isExpired(parseInt(res.data.endTime, 10)));
        if (
          isExpired(parseInt(res.data.endTime, 10)) && 
          this.data.gameStatus === 2 &&
          !this.data.gameEnded
        ) {
          this.endGame();
        }
      })
      .catch((err) => {
        console.log(err);
      });
  },
  async playGame(e) {
    if (btnLock) {
      return;
    }
    
    // 获取点击按钮传入的次数
    const clickedTimes = parseInt(e.currentTarget.dataset.times, 10);
    console.log('pointChanceId', this.data.pointChanceId, clickedTimes);
    
    // 判断是否有游戏凭证
    if (
      this.data.pointChanceId === "0" ||
      this.data.pointChanceId === 0 ||
      !this.data.pointChanceId
    ) {
      // 检查必要参数
      if (!this.data.userId || !this.data.openId) {
        showWxToast("参数异常，请重新进入小程序");
        return;
      }
      
      // 没有游戏凭证时调用playPoint接口
      btnLock = true;
      try {
        const res = await playPoint({
          USER_ID: this.data.userId,
          openid: this.data.openId,
          size: clickedTimes.toString()
        });
        console.log('playPoint接口响应:', res);
        
        // 调用微信支付
        const payRes = await wxPay(res);
        console.log('微信支付结果:', payRes);
        
        // 支付成功后打开 gamePlay 弹窗
        
        // 获取新的游戏信息
        // const pointInfoRes = await getPointInfo({ cancelLoading: true });
        // this.setData({
            //   pointChanceId: pointInfoRes.data.id,
            // });
            
            if(this.data.gameStatus === 2 && !judgeGameEndTimer) {
                console.log('启动judgeGameEnd定时器');
                this.startJudgeGameEndTimer();
            }
            
            btnLock = false;
            this.openDialog({
              dialogType: "gamePlay",
              currentUserInfo: {
                headImg: wx.getStorageSync('headImg') || HEADIMG,
                nickname: wx.getStorageSync('nickname') || '用户'
              },
              currenttimes: clickedTimes
            });
      } catch (err) {
        if (err.errMsg !== "requestPayment:fail cancel") {
          showWxToast("网络异常,请重新进入小程序!");
        }
        console.error('playPoint接口调用失败:', err);
        btnLock = false;
      }
      return;
    }
    
    // 有游戏凭证，提取摇奖次数
    const id = this.data.pointChanceId;
    const timesMatch = id.match(/_(\d+)$/);
    
    if (!timesMatch) {
      // 提取次数失败，提示游戏数据异常
      wx.showToast({
        title: '游戏数据异常，请重新进入',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    const times = parseInt(timesMatch[1], 10);
    console.log('提取到摇奖次数:', times);
    
    // 验证摇奖次数是否有效（只允许1、5或10）
    if (![1, 5, 10].includes(times)) {
      wx.showToast({
        title: '游戏数据异常，请重新进入',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    // 比较提取的次数和点击按钮的次数
    if (times !== clickedTimes) {
      wx.showToast({
        title: `你上次支付的次数是"${times}"，请点击对应按钮消费`,
        icon: 'none',
        duration: 3000
      });
      return;
    }
    
    btnLock = true;
    try {
      const res = await robPoint(id);
      console.log('抢积分成功:', res);
      btnLock = false;
      this.openDialog({
        dialogType: "gamePlay",
        currentUserInfo: {
        headImg: wx.getStorageSync('headImg') || HEADIMG,
        nickname: wx.getStorageSync('nickname') || '用户'
        },
        currenttimes: clickedTimes
    });
    } catch (err) {
      console.error('抢积分失败:', err);
      showWxToast("网络异常,请重新进入小程序!");
      btnLock = false;
    }
  },
  // 清空倒计时计时器
  clearCdTimer() {
    if (timerInterval) {
      clearInterval(timerInterval);
      timerInterval = null;
      this.setData({
        remainTimeFormat: "00:00:00:00",
      });
    }
  },
  // 清空"用于轮询游戏是否开始"的计时器
  clearLoopGameStartTimer() {
    if (loopGameStartTimer) {
      clearInterval(loopGameStartTimer);
      loopGameStartTimer = null;
    }
  },
  // 启动judgeGameEnd定时器
  startJudgeGameEndTimer() {
    if (judgeGameEndTimer) {
      return; // 如果已经存在，不重复启动
    }
    judgeGameEndTimer = setInterval(() => {
      this.judgeGameEnd();
    }, 3000);
  },
  // 清空judgeGameEnd定时器
  clearJudgeGameEndTimer() {
    if (judgeGameEndTimer) {
      clearInterval(judgeGameEndTimer);
      judgeGameEndTimer = null;
    }
  },
  // 轮询游戏是否开始
  loopAskGameIsStart() {
    if (loopGameStartTimer) {
      return;
    }
    loopGameStartTimer = setInterval(() => {
      this.initPointInfo();
    }, 2000);
  },
  updatePlayRecords(playRecords) {
    // 容错：确保传入的是数组
    if (!Array.isArray(playRecords)) {
      return;
    }
    const previousLength = Array.isArray(this.data.playRecords)
      ? this.data.playRecords.length
      : 0;
    // 没有变化直接返回
    if (playRecords.length === previousLength) {
      return;
    }
    // 更新记录
    this.setData({
      playRecords,
      isFirstInitPlayRecord: false,
    });
    // 仅当有新增记录时才弹窗，且保证新记录存在
    const hasNewRecord = playRecords.length > previousLength;
    const newPlayRecord = hasNewRecord ? playRecords[playRecords.length - 1] : null;
      if (newPlayRecord && typeof newPlayRecord === "object") {
        // 检查 localStorage 中的 lastId 是否和新的 id 一样
        if (newPlayRecord.id) {
          const lastId = getLastId();
          if (lastId === newPlayRecord.id) {
            // 如果 id 一样，则不弹窗直接返回
            console.log('lastId === newPlayRecord.id', lastId, newPlayRecord.id);
            return;
          }
          // 保存新记录的 id 到 localStorage
        }

        // 这里添加gamePlay弹窗逻辑
        setLastId(newPlayRecord.id);
        
        // // 先打开gamePlay弹窗
        // this.openDialog({
        //   dialogType: "gamePlay",
        //   currentUserInfo: {
        //     headImg: wx.getStorageSync('headImg') || HEADIMG,
        //     nickname: wx.getStorageSync('nickname') || '用户'
        //   },
        //   currenttimes: newPlayRecord.diceStr.length
        // });
        
       
        timeoutTask(() => {
          const tmpDialogType = newPlayRecord.isChallengeSuccess
            ? "challengeSuccess"
            : "challengeFail";
          this.openDialog({
            dialogType: tmpDialogType,
            diceVal: newPlayRecord.diceVal,
            diceStr: newPlayRecord.diceStr,
          });
        }, 4000);
      }
  },
  onDialogClose() {
    if (this.data.gameStatus === 3) {
      wx.navigateBack();
    }
  },
  onEndConfirm() {
    console.log('用户点击了结束确认按钮');
    if(this.data.rankList && this.data.rankList.length > 0) {
      this.openDialog({
        dialogType: 'gameEnd',
      });
    } else {
      // 如果没有排行榜数据，直接关闭弹窗
      this.setData({
        dialogVisible: false
      });
    }
  },
  /**
   * 处理积分风暴的pointJson数据
   * @param {object} pointData 积分风暴接口返回的数据
   */
  handlePointJsonData(pointData) {
    // 处理 pointJson 数据
    if (pointData && pointData.pointJson) {
      try {
        const pointConfig = JSON.parse(pointData.pointJson);
        console.log('解析后的积分配置:', pointConfig);
        
        // 更新页面数据
        this.setData({
          pointConfig: {
            gameTime: pointConfig.gameTime, // 游戏时长
            perPrice: pointConfig.perPrice, // 每次参与价格
            prizeNum: pointConfig.prizeNum, // 奖品数量
            awardData: pointConfig.awardData, // 奖品数据
          },
          hasCustomConfig: pointConfig.awardData && pointConfig.awardData.length > 0, // 根据奖品数据判断是否有自定义配置
        });
      } catch (parseError) {
        console.error('解析 pointJson 失败:', parseError);
      }
    }
  },
});
